/**
 * Description: 静默连接蓝牙操作，不显示任何提示
 * Date: 2025/2/15
 */

import { ab2hex, setMTu, writeBLEState } from './BluetoothFun'
import store from '@/store'

/**
 * 静默连接蓝牙设备，不显示任何提示
 * 用于在数据索引计数器达到上限时自动重连蓝牙设备
 * @returns {Promise} 返回Promise对象，连接成功时resolve，失败时reject
 */
export const silentConnect = () => {
  return new Promise((resolve, reject) => {
    // 打开蓝牙适配器，不显示任何提示
    uni.openBluetoothAdapter({
      success: (res) => {
        console.log('蓝牙初始化成功（静默模式）')
        // 获取蓝牙适配器状态
        uni.getBluetoothAdapterState({
          success: (res) => {
            console.log('蓝牙适配器状态（静默模式）：', res)
            if (res.available) {
              // 开始搜索蓝牙设备
              let arr = []
              uni.startBluetoothDevicesDiscovery({
                allowDuplicatesKey: false,
                interval: 0,
                success: (res) => {
                  console.log('搜索蓝牙设备成功（静默模式）')
                  uni.onBluetoothDeviceFound((devices) => {
                    uni.getBluetoothDevices({
                      success: (res) => {
                        console.log('设备列表（静默模式）：', res)
                        arr = res.devices
                      },
                    })
                  })

                  // 2秒后停止搜索
                  setTimeout(() => {
                    uni.stopBluetoothDevicesDiscovery({
                      success: (res) => {
                        let searchDeviceName = 'EI-B100'
                        console.log('停止搜索蓝牙设备成功（静默模式）')
                        let DevicesArr = []

                        if (arr.length !== 0) {
                          for (let i = 0; i < arr.length; i++) {
                            if (arr[i].name.indexOf(searchDeviceName) !== -1) {
                              console.log('搜索到的设备是（静默模式）', arr[i])
                              DevicesArr.push(arr[i])
                            }
                          }

                          if (DevicesArr.length === 1) {
                            console.log('DevicesArr[0]（静默模式）', DevicesArr[0])
                            // 建立蓝牙连接
                            const deviceId = DevicesArr[0].deviceId
                            uni.createBLEConnection({
                              deviceId,
                              success: (res) => {
                                console.log('connected success（静默模式）', res)
                                // 获取蓝牙服务
                                setTimeout(() => {
                                  setMTu(deviceId)
                                }, 500)

                                setTimeout(async () => {
                                  uni.getBLEDeviceServices({
                                    deviceId,
                                    success: (res) => {
                                      res.services.forEach((service) => {
                                        if (service.uuid.indexOf('FFE0') !== -1) {
                                          // 在此处开启数据监听 （接收）
                                          uni.onBLECharacteristicValueChange((res) => {
                                            store.dispatch('asyncOriginalData', res.value)
                                            console.log('监听到的蓝牙数据000>>>>>（静默模式）', res.value)
                                            console.log('ab2（静默模式）', ab2hex(res.value))
                                          })
                                          // 获取蓝牙特征值
                                          uni.getBLEDeviceCharacteristics({
                                            deviceId: deviceId,
                                            serviceId: service.uuid,
                                            success: (res) => {
                                              console.log('getBLEDeviceCharacteristics success（静默模式）', res)
                                              res.characteristics.forEach((characteristic) => {
                                                if (characteristic.properties.read) {
                                                  uni.readBLECharacteristicValue({
                                                    characteristicId: characteristic.uuid,
                                                    deviceId,
                                                    serviceId: service.uuid,
                                                  })
                                                }

                                                if (
                                                  characteristic.properties.notify ||
                                                  characteristic.properties.indicate
                                                ) {
                                                  uni.notifyBLECharacteristicValueChange({
                                                    state: true,
                                                    deviceId,
                                                    serviceId: service.uuid,
                                                    characteristicId: characteristic.uuid,
                                                    success(res) {
                                                      // console.log('notifyBLECharacteristicValueChange success', res);
                                                    },
                                                  })
                                                }

                                                if (characteristic.properties.write) {
                                                  store.commit('setDeviceId', deviceId)
                                                  store.commit('setServiceId', service.uuid)
                                                  store.commit('setCharacteristicId', characteristic.uuid)
                                                  setTimeout(() => {
                                                    writeBLEState(10)
                                                    resolve() // 连接成功，解析Promise
                                                  }, 800)
                                                }
                                              })
                                            },
                                            fail: (err) => {
                                              console.error('获取蓝牙特征值失败（静默模式）：', err)
                                              reject(err)
                                            }
                                          })
                                        }
                                      })
                                    },
                                    fail: (err) => {
                                      console.error('获取蓝牙服务失败（静默模式）：', err)
                                      reject(err)
                                    }
                                  })
                                }, 2000)
                              },
                              fail: (err) => {
                                console.error('连接蓝牙设备失败（静默模式）：', err)
                                reject(err)
                              }
                            })
                          } else {
                            console.log('未找到设备或找到多个设备（静默模式）')
                            reject(new Error('未找到设备或找到多个设备'))
                          }
                        } else {
                          console.log('未找到任何设备（静默模式）')
                          reject(new Error('未找到任何设备'))
                        }
                      },
                      fail: (err) => {
                        console.error('停止搜索蓝牙设备失败（静默模式）：', err)
                        reject(err)
                      }
                    })
                  }, 2000)
                },
                fail: (err) => {
                  console.error('搜索蓝牙设备失败（静默模式）：', err)
                  reject(err)
                }
              })
            } else {
              console.error('蓝牙适配器不可用（静默模式）')
              reject(new Error('蓝牙适配器不可用'))
            }
          },
          fail: (err) => {
            console.error('获取蓝牙适配器状态失败（静默模式）：', err)
            reject(err)
          }
        })
      },
      fail: (err) => {
        console.error('蓝牙初始化失败（静默模式）：', err)
        reject(err)
      }
    })
  })
} 